package org.eliza.base.basicx.datatypex

// Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 等。不同于 Java 的是，字符不属于数值类型，是一个独立的数据类型。
/*

    类型	位宽度
    Double	64
    Float	32
    Long	64
    Int	    32
    Short	16
    Byte	8


    十进制：123
    长整型以大写的 L 结尾：123L
    16 进制以 0x 开头：0x0F
    2 进制以 0b 开头：0b00001011
    注意：8进制不支持
    Kotlin 同时也支持传统符号表示的浮点数值：

    Doubles 默认写法: 123.5, 123.5e10
    Floats 使用 f 或者 F 后缀：123.5f

*/

fun format() {
    val oneByte: Byte = 1 // 8
    val one: Int = 1 // Int 32
    val oneShort: Short = 1 // Int 16
    val threeBillion: Long = 3000000000 // Long 64
    val oneLong: Long = 1L // Long
    println("one         :$one")
    println("threeBillion:$threeBillion")
    println("oneLong     :$oneLong")
    println("oneShort    :$oneShort")
    println("oneByte     :$oneByte")

    val oneMillion = 1_000_000
    val creditCardNumber = 1234_5678_9012_3456L
    val socialSecurityNumber = 999_99_9999L
    val hexBytes = 0xFF_EC_DE_5E
    val bytes = 0b11010010_01101001_10010100_10010010
    println("oneMillion         :$oneMillion")
    println("creditCardNumber         :$creditCardNumber")
    println("socialSecurityNumber         :$socialSecurityNumber")
    println("hexBytes         :$hexBytes")
    println("bytes         :$bytes")

}

fun float() {
    val oneFloat: Float = 1f// Long
    val onDouble: Double = 1.0// Long
    println("oneFloat :$oneFloat")
    println("onDouble :$onDouble")
}


/*
*
 比较两个数字
 Kotlin 中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实 Kotlin 帮你封装了一个对象，这样可以保证不会出现空指针。
 数字类型也一样，所以在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。
 在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。
* */
fun Package() {
    println("----Package-----")

    //sampleStart
    val a: Int = 100
    val boxedA: Int? = a
    val anotherBoxedA: Int? = a

    val b: Int = 10000
    val boxedB: Int? = b
    val anotherBoxedB: Int? = b

    // true 对 -128 到 127 的整数（Integer）应用了内存优化，因此，a 的所有可空引用实际上都是同一对象
    println("boxedA == ${boxedA == anotherBoxedA},=== ${boxedA === anotherBoxedA}") // false
    println("boxedB == ${boxedB == anotherBoxedB},=== ${boxedB === anotherBoxedB}") // false
//sampleEnd

    //sampleStart
    val c: Int = 10000
    val boxedC: Int? = c
    val anotherBoxedC: Int? = c
    println("boxedC == ${boxedC == anotherBoxedC},=== ${boxedC === anotherBoxedC}") // false

//sampleEnd
}

fun Math() {
//    shl(bits) – 有符号左移  <<
//    shr(bits) – 有符号右移  >>
//    ushr(bits) – 无符号右移 java`s >>>
//    and(bits) – 位与
//    or(bits) – 位或
//    xor(bits) – 位异或
//    inv() – 位非
//    println((1 << 2)  //err
    println("---Math------")
    println("shl  ${(1 shl 2)}") // 左移
    println("shr  ${(2 * 2 shr 2)}")
    println("ushr  ${(2 * 2 ushr 2)}")
    println("and  ${(1 and 0)}") //按位与
    println("and  ${(1 and 3)}")
    println("or  ${(2 or 2)}") //位或
//    10
//    10
//    10
    println("xor  ${(2 xor 2)}") // 位异或
//    10
//    10
//    00


}

fun range() {
    println("----range-----")
    println("in ${2 in 0..10}")
    println("in ${2 !in 0..10}")
    println("in ${0..10}")

    /*
    *
    *   认为 NaN 与其自身相等
        认为 NaN 比包括正无穷大（POSITIVE_INFINITY）在内的任何其他元素都大
        认为 -0.0 小于 0.0
    * */
    println("< Float.NaN                :${1f < Float.NaN}")
    println("< Double.NaN               :${1.1 < Double.NaN}")
    println(" -0.0 == 0.0               :${-0.0 == 0.0}") //作为浮点数的操作数
    println("listOf(-0.0) == 0.0        :${listOf(0.0) == listOf(-0.0)}") //作为浮点数的操作数
    // 静态类型作为浮点数的操作数
    println("Double.NaN == self         :${Double.NaN == Double.NaN}")
    // 静态类型并非作为浮点数的操作数
    println("listOf(Double.NaN) == self :${listOf(Double.NaN) == listOf(Double.NaN)}")
    println("Double.NaN.isNaN()         :${Double.NaN.isNaN()}")
    println(listOf(Double.NaN, Double.POSITIVE_INFINITY, 0.0, -0.0).sorted())

}

private  fun main() {
    format()
    float()
    Char()
    Boolean()
    println("---------")
    Package()
    Math()
    range()
}

